Shareware Grab Bag

home *** CD-ROM | disk | FTP | other *** search

/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / as04.arc / PROFIL.ASM < prev next >

Wrap

Assembly Source File | 1985-08-06 | 20.6 KB | 705 lines

TITLE PROFIL - MS-DOS Profile program ;Profiler for MS-DOS 1.25 2.00 ; ; Lots of stuff stolen from debug. ; User provides # of paragraphs per bucket, program is cut up accordingly. ; User also specifies clock interval ;System calls PRINTBUF EQU 9 SETDMA EQU 26 CREATE EQU 22 OPEN EQU 15 CLOSE EQU 16 GETBUF EQU 10 BLKWRT EQU 40 BLKRD EQU 39 OUTCH EQU 2 SETBASE EQU 38 FCB EQU 5CH BUFLEN EQU 80 ; FCB offsets RR EQU 33 RECLEN EQU 14 FILELEN EQU 16 ;Segments in load order CODE SEGMENT PUBLIC CODE ENDS DATA SEGMENT BYTE DATA ENDS INIT SEGMENT BYTE INIT ENDS DG GROUP CODE,DATA,INIT ;The data segment DATA SEGMENT BYTE ORG 0 ENDMES DB 13,10,"Program terminated normally",13,10,"$" ABORTMES DB 13,10,"Program aborted",13,10,"$" TOOBIG DB "Program too big",13,10,"$" EXEBAD DB "EXE file bad",13,10,"$" OUT_FCB LABEL WORD DB 0 OUTNAME DB " PRF" DB 30 DUP(0) DB 80H DUP(?) STACK LABEL WORD BYTEBUF DB BUFLEN DUP(?) ;Processed input queue AXSAVE DW ? ;See interrupt routine BXSAVE DW ? ; " " " PROG_AREA DW ? ;Segment of program start ;EXE file header RUNVAR LABEL WORD RELPT DW ? LASTP LABEL WORD RELSEG DW ? PSIZE LABEL WORD PAGES DW ? RELCNT DW ? HEADSIZ DW ? DW ? LOADLOW DW ? PROG_SS LABEL WORD ;Program stack seg INITSS DW ? PROG_SP LABEL WORD ;Program SP INITSP DW ? DW ? PROG_ENTRY EQU THIS DWORD PROG_RA LABEL WORD ;Program start offset INITIP DW ? PROG_SA LABEL WORD ;Program start segment (may be different from PROG_AREA) INITCS DW ? RELTAB DW ? RUNVARSIZ EQU $-RUNVAR EXEFILE DB 0 ;Flag to indicate EXE file DRV_VALID DW ? ;Init for AX register OUTPUT_DATA LABEL WORD ;Start of the profile data CLOCK_GRAIN DW ? ;Clock interval micro-seconds BUCKET_NUM DW ? ;Number of buckets BUCKET_SIZE DW ? ;Paragraphs per bucket PROG_LOW_PA DW ? ;Start of program (PARA #) PROG_HIGH_PA DW ? ;End of program (PARA #) DOS_PA DW ? ;IO-DOS PARA boundry HIT_IO DW 0 ;IO bucket HIT_DOS DW 0 ;DOS bucket HIT_HIGH DW 0 ;Above Program bucket NUM_DATA_WORDS EQU ($-OUTPUT_DATA)/2 ;Number of word items BUCKET LABEL WORD ;Bucket count area ;The following data will be overwritten when the buckets are initialized LINEBUF DB BUFLEN,1,0DH ;Raw input buffer DB BUFLEN DUP(?) NOFILE DB "File not found",13,10,"$" OUTERR DB "Cannot open output file",13,10,"$" GRAIN_PROMPT DB "Sample time (micro-sec) >= 60 ? ","$" SIZE_PROMPT DB "Number of paragraphs (16 bytes) per bucket? ","$" PARAM_PROMPT DB "Parameters to program? ","$" DATA ENDS ;The resident code portion CODE SEGMENT PUBLIC ASSUME CS:DG,DS:DG,ES:DG,SS:DG ;The clock interrupt routine PUBLIC CLK_INTER ;Stuff provided by external clock handler routine EXTRN CLOCKON:NEAR,CLOCKOFF:NEAR,LEAVE_INT:NEAR ORG 100H START: CLD MOV SP,OFFSET DG:STACK ;Use internal stack CALL SETUP ;The following setup stuff cannot be done in SETUP because we're probably ; overwritting the INIT area MOV DX,[PROG_AREA] MOV AH,SETBASE INT 21H ;Set base for program MOV ES,[PROG_AREA] PUSH SI ;Points to BYTEBUF MOV DI,81H ;Set unformatted params COMTAIL: LODSB STOSB CMP AL,13 JNZ COMTAIL SUB DI,82H ;Figure length XCHG AX,DI MOV BYTE PTR ES:[80H],AL POP SI MOV DI,FCB ;First param MOV AX,2901H INT 21H MOV BYTE PTR [DRV_VALID],AL MOV AX,2901H MOV DI,6CH ;Second param INT 21H MOV BYTE PTR [DRV_VALID+1],AL MOV AX,ES ;Prog segment to AX MOV DX,[PROG_RA] ;Offset CMP [EXEFILE],1 JZ EXELOAD ;EXE file JMP BINFIL ;Regular file (.COM) EXELOAD: MOV AX,[HEADSIZ] ;Size of header in paragraphs ADD AX,31 MOV CL,4 ROL AX,CL ;Size in bytes MOV BX,AX AND AX,0FE00H AND BX,0FH MOV WORD PTR DS:[FCB+RR],AX ;Position in file of program MOV WORD PTR DS:[FCB+RR+2],BX ;Record size MOV DX,[PAGES] ;Size in 512 byte blocks DEC DX XCHG DH,DL ROL DX,1 MOV DI,DX MOV SI,DX AND DI,0FE00H AND SI,1FFH SUB DI,AX SBB SI,BX MOV AX,[LASTP] OR AX,AX JNZ PARTP MOV AX,200H PARTP: ADD DI,AX ADC SI,0 MOV AX,DI ADD AX,15 AND AL,0F0H OR AX,SI MOV CL,4 ROR AX,CL XCHG AX,CX MOV BX,[PROG_AREA] ADD BX,10H MOV AX,WORD PTR DS:[2] SUB AX,CX MOV DX,OFFSET DG:TOOBIG JB ERROR CMP BX,AX JA ERROR CMP [LOADLOW],-1 JNZ LOADEXE XCHG AX,BX LOADEXE: MOV BP,AX XOR DX,DX CALL READ JC HAVEXE BADEXE: MOV DX,OFFSET DG:EXEBAD ERROR: MOV AH,PRINTBUF ;Print the message in DX INT 21H INT 20H ;Exit HAVEXE: MOV AX,[RELTAB] ;Get position of relocation table MOV WORD PTR DS:[FCB+RR],AX MOV WORD PTR DS:[FCB+RR+2],0 MOV DX,OFFSET DG:RELPT ;Four byte buffer MOV AH,SETDMA INT 21H CMP [RELCNT],0 JZ NOREL RELOC: MOV AH,BLKRD MOV DX,FCB MOV CX,4 INT 21H ;Read in one relocation pointer OR AL,AL JNZ BADEXE MOV DI,[RELPT] ;Pointer offset MOV AX,[RELSEG] ;pointer segment ADD AX,BP ;Bias with actual load segment MOV ES,AX ADD ES:[DI],BP ;Relocate DEC [RELCNT] JNZ RELOC NOREL: ADD [INITSS],BP ADD [INITCS],BP JMP SHORT PROGGO BINFIL: MOV WORD PTR DS:[FCB+RECLEN],1 MOV SI,-1 MOV DI,SI CALL READ MOV ES,[PROG_SA] ;Prog segment to ES MOV AX,WORD PTR ES:[6] MOV [PROG_SP],AX ;Default SP for non EXE files DEC AH MOV WORD PTR ES:[6],AX ;Fix size PROGGO: PUSH DS MOV AX,[PROG_AREA] MOV DS,AX MOV DX,80H MOV AH,SETDMA INT 21H ;Set default disk transfer address POP DS MOV BX,[BUCKET_NUM] SHL BX,1 ;Mult by 2 to get #bytes in bucket area CLEAR: MOV BUCKET[BX],0 ;Zero counts SUB BX,2 JGE CLEAR MOV DX,[CLOCK_GRAIN] PUSH DS POP ES CLI ;Don't collect data yet CALL CLOCKON ;Set the interrupt MOV SI,[PROG_RA] MOV DI,[PROG_AREA] MOV BX,[PROG_SS] MOV CX,[PROG_SP] MOV AX,[DRV_VALID] MOV DX,[PROG_SA] MOV SS,BX MOV SP,CX XOR CX,CX PUSH CX ;0 on prog stack PUSH DX PUSH SI MOV DS,DI ;Set up segments MOV ES,DI STI ;Start collecting data XXX PROC FAR RET ;Hop to program XXX ENDP READ: ; AX:DX is disk transfer address (segment:offset) ; SI:DI is 32 bit length RDLOOP: MOV BX,DX AND DX,000FH MOV CL,4 SHR BX,CL ADD AX,BX PUSH AX PUSH DX PUSH DS MOV DS,AX MOV AH,SETDMA INT 21H POP DS MOV DX,FCB MOV CX,0FFF0H ;Keep request in segment OR SI,SI ;Need > 64K? JNZ BIGRD MOV CX,DI ;Limit to amount requested BIGRD: MOV AH,BLKRD INT 21H SUB DI,CX ;Subtract off amount done SBB SI,0 ;Ripple carry CMP AL,1 ;EOF? POP DX POP AX ;Restore transfer address JZ RET10 ADD DX,CX ;Bump transfer address by last read MOV BX,SI OR BX,DI ;Finished with request JNZ RDLOOP RET10: STC RET ;Return here on termination or abort TERMINATE: CLI ;Stop collecting data MOV DX,OFFSET DG:ENDMES JMP SHORT WRITEOUT ABORT: CLI ;Stop collecting data MOV DX,OFFSET DG:ABORTMES WRITEOUT: MOV AX,CS MOV DS,AX MOV SS,AX MOV SP,OFFSET DG:STACK ;Use internal stack PUSH DX CALL CLOCKOFF ;Restore original clock routine STI ;Back to normal clock POP DX MOV AH,PRINTBUF INT 21H ;Apropriate termination message MOV [OUT_FCB+14],2 ;Word size records MOV DX,OFFSET DG:OUTPUT_DATA MOV AH,SETDMA INT 21H ;Set the transfer address MOV CX,NUM_DATA_WORDS ADD CX,[BUCKET_NUM] MOV DX,OFFSET DG:OUT_FCB MOV AH,BLKWRT INT 21H ;Write out data MOV DX,OFFSET DG:OUT_FCB MOV AH,CLOSE INT 21H INT 20H ;Exit ;The clock interrupt routine CLK_INTER PROC NEAR CLI PUSH DS PUSH CS POP DS ;Get profile segment MOV [AXSAVE],AX MOV [BXSAVE],BX POP AX ;old DS MOV BX,OFFSET DG:LEAVE_INT PUSH BX PUSH AX PUSH ES PUSH [AXSAVE] PUSH [BXSAVE] PUSH CX PUSH DX ;Stack looks like this ; ; +18 OLDFLAGS ; +16 OLDCS ; +14 OLDIP ; +12 RETURN TO LEAVE_INT ; +10 OLDDS ; +8 OLDES ; +6 OLDAX ; +4 OLDBX ; +2 OLDCX ;SP-> OLDDX MOV BX,SP LES BX,DWORD PTR SS:[BX+14] ;Get CS:IP MOV AX,BX MOV CL,4 SHR AX,CL MOV CX,ES ADD AX,CX ;Paragraph of CS:IP CMP AX,[DOS_PA] ;Below DOS? JB IOHIT CMP AX,[PROG_LOW_PA] ;Below program? JB DOSHIT CMP AX,[PROG_HIGH_PA] ;Above program? JAE MISSH SUB AX,[PROG_LOW_PA] ;Paragraph offset XOR DX,DX DIV [BUCKET_SIZE] MOV BX,AX SHL BX,1 ;Mult by 2 to get byte offset INC BUCKET[BX] JMP SHORT DONE IOHIT: INC [HIT_IO] JMP SHORT DONE DOSHIT: INC [HIT_DOS] JMP SHORT DONE MISSH: INC [HIT_HIGH] DONE: POP DX POP CX POP BX POP AX POP ES POP DS STI RET ;To LEAVE_INT CLK_INTER ENDP CODE ENDS ;The init segment contains code to process input parameters ; It will be blasted as soon as the program to be run is read in ; And/or the bucket area is initialized INIT SEGMENT BYTE ORG 0 SETUP: MOV DX,FCB MOV AH,OPEN INT 21H ;Open program file AND AL,AL JZ OPENOK MOV DX,OFFSET DG:NOFILE JMP ERROR OPENOK: XOR BX,BX MOV WORD PTR DS:[FCB+RR],BX MOV WORD PTR DS:[FCB+RR+2],BX ;RR to 0 MOV SI,FCB MOV DI,OFFSET DG:OUT_FCB MOV CX,4 REP MOVSW MOVSB ;Transfer drive spec and file to output MOV DX,OFFSET DG:OUT_FCB MOV AH,CREATE INT 21H ;Try to create the output file AND AL,AL JZ GETSIZE MOV DX,OFFSET DG:OUTERR JMP ERROR GETSIZE: ;Get bucket size MOV DX,OFFSET DG:SIZE_PROMPT MOV AH,PRINTBUF INT 21H CALL INBUF CALL SCANB JZ GETSIZE ;SCANB went to CR XOR BX,BX INC BX ;Size >=1 CALL GETNUM JC GETSIZE ;Bad number MOV [BUCKET_SIZE],DX CMP WORD PTR DS:[FCB+9],5800H+"E" ;"EX" JNZ NOTEXE CMP BYTE PTR DS:[FCB+11],"E" JNZ NOTEXE LOADEXEHEAD: ;Load the EXE header MOV [EXEFILE],1 MOV DX,OFFSET DG:RUNVAR ;Read header in here MOV AH,SETDMA INT 21H MOV CX,RUNVARSIZ MOV DX,FCB MOV WORD PTR DS:[FCB+RECLEN],1 OR AL,AL MOV AH,BLKRD INT 21H CMP [RELPT],5A4DH ;Magic number JZ EXEOK JMP BADEXE EXEOK: MOV AX,[PAGES] ;Size of file in 512 byte blocks MOV CL,5 SHL AX,CL ;Size in paragraphs JMP SHORT SETBUCKET NOTEXE: MOV AX,WORD PTR DS:[FCB+FILELEN] MOV DX,WORD PTR DS:[FCB+FILELEN+2] ;Size of file in bytes DX:AX ADD AX,15 ADC DX,0 ;Round to PARA MOV CL,4 SHR AX,CL AND AX,0FFFH MOV CL,12 SHL DX,CL AND DX,0F000H OR AX,DX ;Size in paragraphs to AX MOV [PROG_RA],100H ;Default offset SETBUCKET: PUSH AX ;Save size XOR DX,DX DIV [BUCKET_SIZE] INC AX ;Round up MOV [BUCKET_NUM],AX MOV BX,OFFSET DG:BUCKET SHL AX,1 ;Number of bytes in bucket area ADD AX,BX ;Size of profil in bytes ADD AX,15 ;Round up to PARA boundry MOV CL,4 SHR AX,CL ;Number of paragraphs in profil INC AX ;Insurance MOV BX,CS ADD AX,BX MOV [PROG_AREA],AX CMP [EXEFILE],1 JZ SETBOUNDS MOV AX,[PROG_AREA] ;Set up .COM segments MOV [PROG_SS],AX MOV [PROG_SA],AX SETBOUNDS: ;Set the sample window MOV BX,10H ;Get start offset ADD BX,[PROG_AREA] ;PARA # of start MOV [PROG_LOW_PA],BX POP AX ;Recall size of PROG in paragraphs ADD BX,AX MOV [PROG_HIGH_PA],BX SETDOS: XOR DX,DX MOV ES,DX ;look in interrupt area MOV DX,WORD PTR ES:[82H] ;From int #20 MOV [DOS_PA],DX PUSH DS POP ES GETGRAIN: ;Get sample interval MOV DX,OFFSET DG:GRAIN_PROMPT MOV AH,PRINTBUF INT 21H CALL INBUF CALL SCANB JZ GETGRAIN ;SCANB went to CR MOV BX,60 ;Grain >=60 CALL GETNUM JC GETGRAIN ;Bad number MOV [CLOCK_GRAIN],DX MOV DX,OFFSET DG:PARAM_PROMPT MOV AH,PRINTBUF INT 21H CALL INBUF ;Get program parameters MOV AX,2522H ;Set vector 22H MOV DX,OFFSET DG:TERMINATE INT 21H MOV AL,23H ;Set vector 23H MOV DX,OFFSET DG:ABORT INT 21H RET ;Back to resident code GETNUM: ;Get a number, DS:SI points to buffer, carry set if bad XOR DX,DX MOV CL,0 LODSB NUMLP: SUB AL,"0" JB NUMCHK CMP AL,9 JA NUMCHK CMP DX,6553 JAE BADNUM MOV CL,1 PUSH BX MOV BX,DX SHL DX,1 SHL DX,1 ADD DX,BX SHL DX,1 CBW POP BX ADD DX,AX LODSB JMP NUMLP NUMCHK: CMP CL,0 JZ BADNUM CMP BX,DX JA BADNUM CLC RET BADNUM: STC RET INBUF: ;Read in from console, SI points to start on exit MOV AH,GETBUF MOV DX,OFFSET DG:LINEBUF INT 21H MOV SI,2 + OFFSET DG:LINEBUF MOV DI,OFFSET DG:BYTEBUF CASECHK: LODSB CMP AL,'a' JB NOCONV CMP AL,'z' JA NOCONV ADD AL,"A"-"a" ;Convert to upper case NOCONV: STOSB CMP AL,13 JZ INDONE CMP AL,'"' JNZ QUOTSCAN CMP AL,"'" JNZ CASECHK QUOTSCAN: MOV AH,AL KILLSTR: LODSB STOSB CMP AL,13 JZ INDONE CMP AL,AH JNZ KILLSTR JMP SHORT CASECHK INDONE: MOV SI,OFFSET DG:BYTEBUF ;Output CR/LF CRLF: MOV AL,13 CALL OUT MOV AL,10 OUT: PUSH AX PUSH DX AND AL,7FH XCHG AX,DX MOV AH,OUTCH INT 21H POP DX POP AX RET SCANB: ;Scan to first non-blank PUSH AX SCANNEXT: LODSB CMP AL," " JZ SCANNEXT CMP AL,9 JZ SCANNEXT DEC SI POP AX EOLCHK: CMP BYTE PTR[SI],13 RET INIT ENDS END START